/**
 * @fileoverview   dom/select  查询元素

 * @date: 11-11-4
 * @time: 上午10:33
 * @author 2kid
 * @version 0.001
 */


F.reg('dom/select', function (f, dom) {
    var win = window, doc = win['document'], docElement = doc.documentElement;
    f.extend(dom, {


        /**
         * @name F.Dom.select
         * @namespace 选择器核心，可扩展。
         * @object
         * @version 0.5

         */
        select:{
            /**
             * @param seletor
             * @param {Array}
                */
            exec:function (seletor, stack) {
                var elem = [];
                //如果没有父元素
                stack = stack || [doc];
                if (stack.length > 0) {
                    // 使用querySelectorAll
                    if ('querySelectorAll' in stack[0]) {
                        f.each(stack, function (p) {
                            elem = f.merge(elem, p.querySelectorAll(seletor));
                        });
                    } else {
                        var selparse = this._selparse,
                            //选择器数组
                            selarr = seletor.match(/\S+/g);
                        //循环每个选择器集
                        for (var i = 0, ilen = selarr.length; i < ilen; i++) {
                            //匹配每个选择器

                            f.each(selparse, function (selreg, selkey) {
                                //selreg 已定义选择器匹配表达式
                                if (selreg.test(selarr[i])) {

                                    if (!stack[0]) return;

                                    //调用匹配选择器的函数
                                    elem = this._selquery[selkey].call(this, selarr[i], stack, selreg);
                                    stack = elem;

                                }
                            }, this);

                        }
                    }
                }


                return elem;
            },
            /***
             *
             * @name F.Dom.select.add
             * @function
             * @param parse 匹配选择器正则
             * @param fn(sel,stack,selreg) sel匹配选择器字符串，stack当前获取到的元素数组，selreg匹配选择器正则
             * @namespace 扩展选择器
             * @example
             *
             * 示例，添加属性选择器
             *  第一个参数，，第二个对应调用的函数，
             *  dom.select.add(/^([a-zA-Z]+)\[(.*)="(.*)"\]/,function(sel, stack, selreg){
             *     var elem = [],selarr = sel.match(selreg);
             *      F.each(stack, function(p) {
             *          elem = F.merge(elem, F.filter(p.getElementsByTagName(selarr[1]), function(ele) {
             *               if (!ele.getAttribute(selarr[2], 2)) return false;
             *              return F.trim(ele.getAttribute(selarr[2], 2)) === F.trim(selarr[3]);
             *          }));
             *      });
             *   return elem;
             *  });

             */
            add:function (parse, fn) {
                this._selparse.push(parse);
                this._selquery.push(fn);
            },
            _selparse:[
                /^[a-z]*#.+$/i,
                /^[a-z]+$/i,
                /^[a-z]*\..+/i
            ],
            _selquery:[
                function (sel, stack, selreg) {
                    //id 选择器
                    var elem = [], selarr = sel.split('#');
                    f.each(stack, function (p) {
                        var tmpelem = p.getElementById(selarr[1]);
                        if (selarr[0].length > 0) {
                            if (tmpelem.nodeName.toLowerCase() == selarr[0].toLowerCase()) {
                                elem.push(tmpelem);
                            }
                        } else {
                            elem.push(tmpelem);
                        }
                    });

                    return elem;
                }, function (sel, stack) {
                    //tag 选择器
                    var elem = [];
                    f.each(stack, function (p) {
                        elem = f.merge(elem, p.getElementsByTagName(sel));
                    });
                    return elem;
                },
                function (sel, stack) {
                    //class 选择器
                    var elem = [], selarr = sel.split('.'),
                        tag = selarr[0].length ? selarr[0] : '*';
                    f.each(stack, function (p) {
                        elem = f.merge(elem, f.filter(p.getElementsByTagName(tag), function (ele) {
                            if (!ele.className) return false;
                            return f.inarray(ele.className.match(/\S+/g), selarr[1]) > -1;
                        }));
                    });
                    return elem;
                }
            ]

        }
    }, true);

    return dom;
}, {


});